using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("AssetLoader")]
	public class AssetLoader : MonoBehaviour
	{
		public enum LOADING_METHOD
		{
			INVALID,
			EDITOR_FILES,
			ASSET_BUNDLES
		}

		[Attribute38("AssetLoader.LoadSoundCallbackData")]
		public class LoadSoundCallbackData : MonoClass
		{
			public object callbackData => method_3<object>("callbackData");

			public LoadSoundCallbackData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public LoadSoundCallbackData(IntPtr address)
				: this(address, "LoadSoundCallbackData")
			{
			}
		}

		public static bool DOWNLOADABLE_LANGUAGE_PACKS => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "AssetLoader", "DOWNLOADABLE_LANGUAGE_PACKS");

		public Vector3 SPAWN_POS_CAMERA_OFFSET => method_2<Vector3>("SPAWN_POS_CAMERA_OFFSET");

		public static float FILE_CACHE_MAX_TIME_PER_FRAME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "AssetLoader", "FILE_CACHE_MAX_TIME_PER_FRAME");

		public bool m_ready => method_2<bool>("m_ready");

		public static string s_workingDir => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "AssetLoader", "s_workingDir");

		public List<GameObject> m_waitingOnObjects => method_3<Class271<GameObject>>("m_waitingOnObjects")?.method_25();

		public static string s_fileInfoCachePath => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "AssetLoader", "s_fileInfoCachePath");

		public static List<string> s_cardSetDirectories => MonoClass.smethod_7<Class249>(TritonHs.MainAssemblyPath, "", "AssetLoader", "s_cardSetDirectories")?.method_25();

		public static LOADING_METHOD s_loadingMethod => MonoClass.smethod_6<LOADING_METHOD>(TritonHs.MainAssemblyPath, "", "AssetLoader", "s_loadingMethod");

		public static string fileListInExtraBundlesTxtName_ => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "AssetLoader", "fileListInExtraBundlesTxtName_");

		public static LOADING_METHOD LoadingMethod => MonoClass.smethod_14<LOADING_METHOD>(TritonHs.MainAssemblyPath, "", "AssetLoader", "get_LoadingMethod", Array.Empty<object>());

		public AssetLoader(IntPtr address, string className)
			: base(address, className)
		{
		}

		public AssetLoader(IntPtr address)
			: this(address, "AssetLoader")
		{
		}

		public static AssetLoader Get()
		{
			return MonoClass.smethod_15<AssetLoader>(TritonHs.MainAssemblyPath, "", "AssetLoader", "Get", Array.Empty<object>());
		}

		public static string CreateLocalFilePath(string relPath, bool useAssetBundleFolder)
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "AssetLoader", "CreateLocalFilePath", relPath, useAssetBundleFolder);
		}

		public static int GetAssetBundleIndex(AssetReference assetRef, int numMaxBundles)
		{
			return MonoClass.smethod_14<int>(TritonHs.MainAssemblyPath, "", "AssetLoader", "GetAssetBundleIndex", new object[2] { assetRef, numMaxBundles });
		}

		public static int GetAssetBundleIndexFromPath(string assetPath, int numMaxBundles)
		{
			return MonoClass.smethod_14<int>(TritonHs.MainAssemblyPath, "", "AssetLoader", "GetAssetBundleIndexFromPath", new object[2] { assetPath, numMaxBundles });
		}

		public static void InitFileListInExtraBundles()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "AssetLoader", "InitFileListInExtraBundles");
		}

		public static bool UseFileListInExtraBundles()
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "AssetLoader", "UseFileListInExtraBundles", Array.Empty<object>());
		}

		public static bool FileIsInFileListInExtraBundles(string fileName)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "AssetLoader", "FileIsInFileListInExtraBundles", new object[1] { fileName });
		}

		public static int AvailableExtraAssetBundlesCount()
		{
			return MonoClass.smethod_14<int>(TritonHs.MainAssemblyPath, "", "AssetLoader", "AvailableExtraAssetBundlesCount", Array.Empty<object>());
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void WillReset()
		{
			method_8("WillReset");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void OnApplicationQuit()
		{
			method_8("OnApplicationQuit");
		}

		public bool IsReady()
		{
			return method_11<bool>("IsReady", Array.Empty<object>());
		}

		public void SetReady(bool ready)
		{
			method_8("SetReady", ready);
		}

		public bool IsWaitingOnObject(GameObject go)
		{
			return method_11<bool>("IsWaitingOnObject", new object[1] { go });
		}

		public void PrintCachedAssets()
		{
			method_8("PrintCachedAssets");
		}

		public GameObject LoadActor(AssetReference assetRef, bool usePrefabPosition, bool persistent)
		{
			return method_15<GameObject>("LoadActor", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean
			}, new object[3] { assetRef, usePrefabPosition, persistent });
		}

		public GameObject LoadCardPrefab(string cardId, bool usePrefabPosition, bool persistent)
		{
			return method_15<GameObject>("LoadCardPrefab", new Class276.Enum20[3]
			{
				Class276.Enum20.String,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean
			}, new object[3] { cardId, usePrefabPosition, persistent });
		}

		public Texture LoadCardTexture(AssetReference assetRef, bool persistent)
		{
			return method_14<Texture>("LoadCardTexture", new object[2] { assetRef, persistent });
		}

		public Material LoadPremiumMaterial(AssetReference assetRef, bool persistent)
		{
			return method_14<Material>("LoadPremiumMaterial", new object[2] { assetRef, persistent });
		}

		public void LoadSoundCallback(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("LoadSoundCallback", assetRef, go, callbackData);
		}

		public Asset GetLocalizedAsset(AssetReference assetRef, AssetFamily family, bool persistent)
		{
			return method_14<Asset>("GetLocalizedAsset", new object[3] { assetRef, family, persistent });
		}

		public AssetReference GetLocalizedAssetRef(AssetReference assetRef)
		{
			return method_15<AssetReference>("GetLocalizedAssetRef", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { assetRef });
		}

		public AssetReference GetLocalizedAssetRef(AssetReference assetRef, Locale locale)
		{
			return method_15<AssetReference>("GetLocalizedAssetRef", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType
			}, new object[2] { assetRef, locale });
		}

		public bool LocalizeSoundPrefab(AssetReference assetRef, GameObject go, bool logLocalizationError)
		{
			return method_11<bool>("LocalizeSoundPrefab", new object[3] { assetRef, go, logLocalizationError });
		}

		public GameObject LoadSound(AssetReference assetRef, bool usePrefabPosition, bool persistent, bool logLocalizationError)
		{
			return method_15<GameObject>("LoadSound", new Class276.Enum20[4]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean
			}, new object[4] { assetRef, usePrefabPosition, persistent, logLocalizationError });
		}

		public UnityObject LoadAudioClip(AssetReference assetRef, bool disableLocalization, bool persistent)
		{
			return method_14<UnityObject>("LoadAudioClip", new object[3] { assetRef, disableLocalization, persistent });
		}

		public Texture LoadTexture(AssetReference assetRef, bool persistent, bool disableLocalization)
		{
			return method_15<Texture>("LoadTexture", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean
			}, new object[3] { assetRef, persistent, disableLocalization });
		}

		public GameObject LoadUIScreen(AssetReference assetRef, bool usePrefabPosition, bool persistent)
		{
			return method_15<GameObject>("LoadUIScreen", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean
			}, new object[3] { assetRef, usePrefabPosition, persistent });
		}

		public GameObject LoadSpell(AssetReference assetRef, bool usePrefabPosition, bool persistent)
		{
			return method_15<GameObject>("LoadSpell", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean
			}, new object[3] { assetRef, usePrefabPosition, persistent });
		}

		public GameObject LoadGameObject(AssetReference assetRef, bool usePrefabPosition, bool persistent, bool useLocalization)
		{
			return method_15<GameObject>("LoadGameObject", new Class276.Enum20[4]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean
			}, new object[4] { assetRef, usePrefabPosition, persistent, useLocalization });
		}

		public GameObject LoadCardBack(AssetReference assetRef, bool usePrefabPosition, bool persistent)
		{
			return method_15<GameObject>("LoadCardBack", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean
			}, new object[3] { assetRef, usePrefabPosition, persistent });
		}

		public void UnloadUpdatableBundles()
		{
			method_8("UnloadUpdatableBundles");
		}

		public void ReloadUpdatableBundles()
		{
			method_8("ReloadUpdatableBundles");
		}

		public void CacheAsset(Asset asset, object assetObject)
		{
			method_8("CacheAsset", asset, assetObject);
		}

		public void InitCardDirectories(string root)
		{
			method_8("InitCardDirectories", root);
		}

		public UnityObject LoadAssetFromProject(Asset asset, Type assetType)
		{
			return method_14<UnityObject>("LoadAssetFromProject", new object[2] { asset, assetType });
		}

		public AssetReference GetCardDefAssetRefFromCardId(string cardId, string extension)
		{
			return method_14<AssetReference>("GetCardDefAssetRefFromCardId", new object[2] { cardId, extension });
		}

		public bool CanLoadAssetRef(AssetReference assetRef)
		{
			return method_11<bool>("CanLoadAssetRef", new object[1] { assetRef });
		}

		public UnityObject LoadAssetFromProject_Direct(AssetReference assetRef, Type assetType, bool checkName)
		{
			return method_14<UnityObject>("LoadAssetFromProject_Direct", new object[3] { assetRef, assetType, checkName });
		}

		public bool IsAssetNamedProperly(AssetReference assetRef)
		{
			return method_11<bool>("IsAssetNamedProperly", new object[1] { assetRef });
		}

		public void PreloadBundles()
		{
			method_8("PreloadBundles");
		}

		public GameObject LoadGameObjectImmediately(Asset asset, bool usePrefabPosition, GameObject fallback)
		{
			return method_14<GameObject>("LoadGameObjectImmediately", new object[3] { asset, usePrefabPosition, fallback });
		}

		public UnityObject LoadObjectImmediately(Asset asset)
		{
			return method_14<UnityObject>("LoadObjectImmediately", new object[1] { asset });
		}

		public Vector3 NewGameObjectSpawnPosition(object prefab)
		{
			return method_11<Vector3>("NewGameObjectSpawnPosition", new object[1] { prefab });
		}

		public bool AssetFromDownloadablePack(Asset asset)
		{
			return method_11<bool>("AssetFromDownloadablePack", new object[1] { asset });
		}
	}
}
